home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / JapaneseImperialCalendar.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  18.8 KB  |  1,617 lines
  1. package java.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import sun.util.calendar.BaseCalendar;
  6. import sun.util.calendar.CalendarDate;
  7. import sun.util.calendar.CalendarSystem;
  8. import sun.util.calendar.CalendarUtils;
  9. import sun.util.calendar.Era;
  10. import sun.util.calendar.Gregorian;
  11. import sun.util.calendar.LocalGregorianCalendar;
  12. import sun.util.calendar.ZoneInfo;
  13. import sun.util.resources.LocaleData;
  14.  
  15. class JapaneseImperialCalendar extends Calendar {
  16.    public static final int BEFORE_MEIJI = 0;
  17.    public static final int MEIJI = 1;
  18.    public static final int TAISHO = 2;
  19.    public static final int SHOWA = 3;
  20.    public static final int HEISEI = 4;
  21.    private static final int EPOCH_OFFSET = 719163;
  22.    private static final int EPOCH_YEAR = 1970;
  23.    private static final int ONE_SECOND = 1000;
  24.    private static final int ONE_MINUTE = 60000;
  25.    private static final int ONE_HOUR = 3600000;
  26.    private static final long ONE_DAY = 86400000L;
  27.    private static final long ONE_WEEK = 604800000L;
  28.    private static final LocalGregorianCalendar jcal = (LocalGregorianCalendar)CalendarSystem.forName("japanese");
  29.    private static final Gregorian gcal = CalendarSystem.getGregorianCalendar();
  30.    private static final Era BEFORE_MEIJI_ERA = new Era("BeforeMeiji", "BM", Long.MIN_VALUE, false);
  31.    private static final Era[] eras;
  32.    private static final long[] sinceFixedDates;
  33.    static final int[] MIN_VALUES = new int[]{0, -292275055, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, -46800000, 0};
  34.    static final int[] LEAST_MAX_VALUES = new int[]{0, 0, 0, 0, 4, 28, 0, 7, 4, 1, 11, 23, 59, 59, 999, 50400000, 1200000};
  35.    static final int[] MAX_VALUES = new int[]{0, 292278994, 11, 53, 6, 31, 366, 7, 6, 1, 11, 23, 59, 59, 999, 50400000, 7200000};
  36.    private static final long serialVersionUID = -3364572813905467929L;
  37.    private transient LocalGregorianCalendar.Date jdate;
  38.    private transient int[] zoneOffsets;
  39.    private transient int[] originalFields;
  40.    private transient long cachedFixedDate = Long.MIN_VALUE;
  41.  
  42.    public JapaneseImperialCalendar(TimeZone var1, Locale var2) {
  43.       super(var1, var2);
  44.       this.jdate = jcal.newCalendarDate(var1);
  45.       this.setTimeInMillis(System.currentTimeMillis());
  46.    }
  47.  
  48.    public boolean equals(Object var1) {
  49.       return var1 instanceof JapaneseImperialCalendar && super.equals(var1);
  50.    }
  51.  
  52.    public int hashCode() {
  53.       return super.hashCode() ^ this.jdate.hashCode();
  54.    }
  55.  
  56.    public void add(int var1, int var2) {
  57.       if (var2 != 0) {
  58.          if (var1 >= 0 && var1 < 15) {
  59.             this.complete();
  60.             if (var1 == 1) {
  61.                LocalGregorianCalendar.Date var3 = (LocalGregorianCalendar.Date)this.jdate.clone();
  62.                var3.addYear(var2);
  63.                this.pinDayOfMonth(var3);
  64.                this.set(0, getEraIndex(var3));
  65.                this.set(1, var3.getYear());
  66.                this.set(2, var3.getMonth() - 1);
  67.                this.set(5, var3.getDayOfMonth());
  68.             } else if (var1 == 2) {
  69.                LocalGregorianCalendar.Date var12 = (LocalGregorianCalendar.Date)this.jdate.clone();
  70.                var12.addMonth(var2);
  71.                this.pinDayOfMonth(var12);
  72.                this.set(0, getEraIndex(var12));
  73.                this.set(1, var12.getYear());
  74.                this.set(2, var12.getMonth() - 1);
  75.                this.set(5, var12.getDayOfMonth());
  76.             } else if (var1 == 0) {
  77.                int var13 = this.internalGet(0) + var2;
  78.                if (var13 < 0) {
  79.                   var13 = 0;
  80.                } else if (var13 > eras.length - 1) {
  81.                   var13 = eras.length - 1;
  82.                }
  83.  
  84.                this.set(0, var13);
  85.             } else {
  86.                long var14 = (long)var2;
  87.                long var5 = 0L;
  88.                switch (var1) {
  89.                   case 3:
  90.                   case 4:
  91.                   case 8:
  92.                      var14 *= 7L;
  93.                   case 5:
  94.                   case 6:
  95.                   case 7:
  96.                   case 14:
  97.                   default:
  98.                      break;
  99.                   case 9:
  100.                      var14 = (long)(var2 / 2);
  101.                      var5 = (long)(12 * (var2 % 2));
  102.                      break;
  103.                   case 10:
  104.                   case 11:
  105.                      var14 *= 3600000L;
  106.                      break;
  107.                   case 12:
  108.                      var14 *= 60000L;
  109.                      break;
  110.                   case 13:
  111.                      var14 *= 1000L;
  112.                }
  113.  
  114.                if (var1 >= 10) {
  115.                   this.setTimeInMillis(this.time + var14);
  116.                   return;
  117.                }
  118.  
  119.                long var7 = this.cachedFixedDate;
  120.                var5 += (long)this.internalGet(11);
  121.                var5 *= 60L;
  122.                var5 += (long)this.internalGet(12);
  123.                var5 *= 60L;
  124.                var5 += (long)this.internalGet(13);
  125.                var5 *= 1000L;
  126.                var5 += (long)this.internalGet(14);
  127.                if (var5 >= 86400000L) {
  128.                   ++var7;
  129.                   var5 -= 86400000L;
  130.                } else if (var5 < 0L) {
  131.                   --var7;
  132.                   var5 += 86400000L;
  133.                }
  134.  
  135.                var7 += var14;
  136.                int var9 = this.internalGet(15) + this.internalGet(16);
  137.                this.setTimeInMillis((var7 - 719163L) * 86400000L + var5 - (long)var9);
  138.                var9 -= this.internalGet(15) + this.internalGet(16);
  139.                if (var9 != 0) {
  140.                   this.setTimeInMillis(this.time + (long)var9);
  141.                   long var10 = this.cachedFixedDate;
  142.                   if (var10 != var7) {
  143.                      this.setTimeInMillis(this.time - (long)var9);
  144.                   }
  145.                }
  146.             }
  147.  
  148.          } else {
  149.             throw new IllegalArgumentException();
  150.          }
  151.       }
  152.    }
  153.  
  154.    public void roll(int var1, boolean var2) {
  155.       this.roll(var1, var2 ? 1 : -1);
  156.    }
  157.  
  158.    public void roll(int var1, int var2) {
  159.       if (var2 != 0) {
  160.          if (var1 >= 0 && var1 < 15) {
  161.             this.complete();
  162.             int var3 = this.getMinimum(var1);
  163.             int var4 = this.getMaximum(var1);
  164.             switch (var1) {
  165.                case 0:
  166.                case 9:
  167.                case 12:
  168.                case 13:
  169.                case 14:
  170.                default:
  171.                   break;
  172.                case 1:
  173.                   var3 = this.getActualMinimum(var1);
  174.                   var4 = this.getActualMaximum(var1);
  175.                   break;
  176.                case 2:
  177.                   if (!this.isTransitionYear(this.jdate.getNormalizedYear())) {
  178.                      int var30 = this.jdate.getYear();
  179.                      if (var30 == this.getMaximum(1)) {
  180.                         LocalGregorianCalendar.Date var39 = jcal.getCalendarDate(this.time, this.getZone());
  181.                         LocalGregorianCalendar.Date var49 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  182.                         var4 = ((CalendarDate)var49).getMonth() - 1;
  183.                         int var60 = getRolledValue(this.internalGet(var1), var2, var3, var4);
  184.                         if (var60 == var4) {
  185.                            ((CalendarDate)var39).addYear(-400);
  186.                            ((CalendarDate)var39).setMonth(var60 + 1);
  187.                            if (((CalendarDate)var39).getDayOfMonth() > ((CalendarDate)var49).getDayOfMonth()) {
  188.                               ((CalendarDate)var39).setDayOfMonth(((CalendarDate)var49).getDayOfMonth());
  189.                               jcal.normalize(var39);
  190.                            }
  191.  
  192.                            if (((CalendarDate)var39).getDayOfMonth() == ((CalendarDate)var49).getDayOfMonth() && ((CalendarDate)var39).getTimeOfDay() > ((CalendarDate)var49).getTimeOfDay()) {
  193.                               ((CalendarDate)var39).setMonth(var60 + 1);
  194.                               ((CalendarDate)var39).setDayOfMonth(((CalendarDate)var49).getDayOfMonth() - 1);
  195.                               jcal.normalize(var39);
  196.                               var60 = ((CalendarDate)var39).getMonth() - 1;
  197.                            }
  198.  
  199.                            this.set(5, ((CalendarDate)var39).getDayOfMonth());
  200.                         }
  201.  
  202.                         this.set(2, var60);
  203.                      } else if (var30 == this.getMinimum(1)) {
  204.                         LocalGregorianCalendar.Date var40 = jcal.getCalendarDate(this.time, this.getZone());
  205.                         LocalGregorianCalendar.Date var50 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  206.                         var3 = ((CalendarDate)var50).getMonth() - 1;
  207.                         int var61 = getRolledValue(this.internalGet(var1), var2, var3, var4);
  208.                         if (var61 == var3) {
  209.                            ((CalendarDate)var40).addYear(400);
  210.                            ((CalendarDate)var40).setMonth(var61 + 1);
  211.                            if (((CalendarDate)var40).getDayOfMonth() < ((CalendarDate)var50).getDayOfMonth()) {
  212.                               ((CalendarDate)var40).setDayOfMonth(((CalendarDate)var50).getDayOfMonth());
  213.                               jcal.normalize(var40);
  214.                            }
  215.  
  216.                            if (((CalendarDate)var40).getDayOfMonth() == ((CalendarDate)var50).getDayOfMonth() && ((CalendarDate)var40).getTimeOfDay() < ((CalendarDate)var50).getTimeOfDay()) {
  217.                               ((CalendarDate)var40).setMonth(var61 + 1);
  218.                               ((CalendarDate)var40).setDayOfMonth(((CalendarDate)var50).getDayOfMonth() + 1);
  219.                               jcal.normalize(var40);
  220.                               var61 = ((CalendarDate)var40).getMonth() - 1;
  221.                            }
  222.  
  223.                            this.set(5, ((CalendarDate)var40).getDayOfMonth());
  224.                         }
  225.  
  226.                         this.set(2, var61);
  227.                      } else {
  228.                         int var41 = (this.internalGet(2) + var2) % 12;
  229.                         if (var41 < 0) {
  230.                            var41 += 12;
  231.                         }
  232.  
  233.                         this.set(2, var41);
  234.                         int var51 = this.monthLength(var41);
  235.                         if (this.internalGet(5) > var51) {
  236.                            this.set(5, var51);
  237.                         }
  238.                      }
  239.                   } else {
  240.                      int var31 = getEraIndex(this.jdate);
  241.                      CalendarDate var42 = null;
  242.                      if (this.jdate.getYear() == 1) {
  243.                         var42 = eras[var31].getSinceDate();
  244.                         var3 = var42.getMonth() - 1;
  245.                      } else if (var31 < eras.length - 1) {
  246.                         var42 = eras[var31 + 1].getSinceDate();
  247.                         if (var42.getYear() == this.jdate.getNormalizedYear()) {
  248.                            var4 = var42.getMonth() - 1;
  249.                            if (var42.getDayOfMonth() == 1) {
  250.                               --var4;
  251.                            }
  252.                         }
  253.                      }
  254.  
  255.                      if (var3 == var4) {
  256.                         return;
  257.                      }
  258.  
  259.                      int var52 = getRolledValue(this.internalGet(var1), var2, var3, var4);
  260.                      this.set(2, var52);
  261.                      if (var52 == var3) {
  262.                         if ((var42.getMonth() != 1 || var42.getDayOfMonth() != 1) && this.jdate.getDayOfMonth() < var42.getDayOfMonth()) {
  263.                            this.set(5, var42.getDayOfMonth());
  264.                         }
  265.                      } else if (var52 == var4 && var42.getMonth() - 1 == var52) {
  266.                         int var62 = var42.getDayOfMonth();
  267.                         if (this.jdate.getDayOfMonth() >= var62) {
  268.                            this.set(5, var62 - 1);
  269.                         }
  270.                      }
  271.                   }
  272.  
  273.                   return;
  274.                case 3:
  275.                   int var29 = this.jdate.getNormalizedYear();
  276.                   var4 = this.getActualMaximum(3);
  277.                   this.set(7, this.internalGet(7));
  278.                   int var38 = this.internalGet(3);
  279.                   int var47 = var38 + var2;
  280.                   if (this.isTransitionYear(this.jdate.getNormalizedYear())) {
  281.                      long var58 = this.cachedFixedDate;
  282.                      long var69 = var58 - (long)(7 * (var38 - var3));
  283.                      LocalGregorianCalendar.Date var74 = getCalendarDate(var69);
  284.                      if (var74.getEra() != this.jdate.getEra() || var74.getYear() != this.jdate.getYear()) {
  285.                         ++var3;
  286.                      }
  287.  
  288.                      var58 += (long)(7 * (var4 - var38));
  289.                      jcal.getCalendarDateFromFixedDate(var74, var58);
  290.                      if (var74.getEra() != this.jdate.getEra() || var74.getYear() != this.jdate.getYear()) {
  291.                         --var4;
  292.                      }
  293.  
  294.                      var47 = getRolledValue(var38, var2, var3, var4) - 1;
  295.                      var74 = getCalendarDate(var69 + (long)(var47 * 7));
  296.                      this.set(2, var74.getMonth() - 1);
  297.                      this.set(5, var74.getDayOfMonth());
  298.                      return;
  299.                   }
  300.  
  301.                   int var57 = this.jdate.getYear();
  302.                   if (var57 == this.getMaximum(1)) {
  303.                      var4 = this.getActualMaximum(3);
  304.                   } else if (var57 == this.getMinimum(1)) {
  305.                      var3 = this.getActualMinimum(3);
  306.                      var4 = this.getActualMaximum(3);
  307.                      if (var47 > var3 && var47 < var4) {
  308.                         this.set(3, var47);
  309.                         return;
  310.                      }
  311.                   }
  312.  
  313.                   if (var47 > var3 && var47 < var4) {
  314.                      this.set(3, var47);
  315.                      return;
  316.                   }
  317.  
  318.                   long var65 = this.cachedFixedDate;
  319.                   long var72 = var65 - (long)(7 * (var38 - var3));
  320.                   if (var57 != this.getMinimum(1)) {
  321.                      if (gcal.getYearFromFixedDate(var72) != var29) {
  322.                         ++var3;
  323.                      }
  324.                   } else {
  325.                      LocalGregorianCalendar.Date var76 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  326.                      if (var72 < jcal.getFixedDate(var76)) {
  327.                         ++var3;
  328.                      }
  329.                   }
  330.  
  331.                   var65 += (long)(7 * (var4 - this.internalGet(3)));
  332.                   if (gcal.getYearFromFixedDate(var65) != var29) {
  333.                      --var4;
  334.                   }
  335.                   break;
  336.                case 4:
  337.                   boolean var28 = this.isTransitionYear(this.jdate.getNormalizedYear());
  338.                   int var37 = this.internalGet(7) - this.getFirstDayOfWeek();
  339.                   if (var37 < 0) {
  340.                      var37 += 7;
  341.                   }
  342.  
  343.                   long var46 = this.cachedFixedDate;
  344.                   long var64;
  345.                   int var71;
  346.                   if (var28) {
  347.                      var64 = this.getFixedDateMonth1(this.jdate, var46);
  348.                      var71 = this.actualMonthLength();
  349.                   } else {
  350.                      var64 = var46 - (long)this.internalGet(5) + 1L;
  351.                      var71 = jcal.getMonthLength(this.jdate);
  352.                   }
  353.  
  354.                   LocalGregorianCalendar var77 = jcal;
  355.                   long var73 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var64 + 6L, this.getFirstDayOfWeek());
  356.                   if ((int)(var73 - var64) >= this.getMinimalDaysInFirstWeek()) {
  357.                      var73 -= 7L;
  358.                   }
  359.  
  360.                   var4 = this.getActualMaximum(var1);
  361.                   int var14 = getRolledValue(this.internalGet(var1), var2, 1, var4) - 1;
  362.                   long var15 = var73 + (long)(var14 * 7) + (long)var37;
  363.                   if (var15 < var64) {
  364.                      var15 = var64;
  365.                   } else if (var15 >= var64 + (long)var71) {
  366.                      var15 = var64 + (long)var71 - 1L;
  367.                   }
  368.  
  369.                   this.set(5, (int)(var15 - var64) + 1);
  370.                   return;
  371.                case 5:
  372.                   if (this.isTransitionYear(this.jdate.getNormalizedYear())) {
  373.                      long var27 = this.getFixedDateMonth1(this.jdate, this.cachedFixedDate);
  374.                      int var45 = getRolledValue((int)(this.cachedFixedDate - var27), var2, 0, this.actualMonthLength() - 1);
  375.                      LocalGregorianCalendar.Date var56 = getCalendarDate(var27 + (long)var45);
  376.                      if ($assertionsDisabled || getEraIndex(var56) == this.internalGetEra() && var56.getYear() == this.internalGet(1) && var56.getMonth() - 1 == this.internalGet(2)) {
  377.                         this.set(5, var56.getDayOfMonth());
  378.                         return;
  379.                      }
  380.  
  381.                      throw new AssertionError();
  382.                   }
  383.  
  384.                   var4 = jcal.getMonthLength(this.jdate);
  385.                   break;
  386.                case 6:
  387.                   var4 = this.getActualMaximum(var1);
  388.                   if (this.isTransitionYear(this.jdate.getNormalizedYear())) {
  389.                      int var26 = getRolledValue(this.internalGet(6), var2, var3, var4);
  390.                      long var36 = this.cachedFixedDate - (long)this.internalGet(6);
  391.                      LocalGregorianCalendar.Date var55 = getCalendarDate(var36 + (long)var26);
  392.                      if ($assertionsDisabled || getEraIndex(var55) == this.internalGetEra() && var55.getYear() == this.internalGet(1)) {
  393.                         this.set(2, var55.getMonth() - 1);
  394.                         this.set(5, var55.getDayOfMonth());
  395.                         return;
  396.                      }
  397.  
  398.                      throw new AssertionError();
  399.                   }
  400.                   break;
  401.                case 7:
  402.                   int var25 = this.jdate.getNormalizedYear();
  403.                   if (!this.isTransitionYear(var25) && !this.isTransitionYear(var25 - 1)) {
  404.                      int var33 = this.internalGet(3);
  405.                      if (var33 > 1 && var33 < 52) {
  406.                         this.set(3, this.internalGet(3));
  407.                         var4 = 7;
  408.                         break;
  409.                      }
  410.                   }
  411.  
  412.                   var2 %= 7;
  413.                   if (var2 == 0) {
  414.                      return;
  415.                   }
  416.  
  417.                   long var34 = this.cachedFixedDate;
  418.                   LocalGregorianCalendar var10000 = jcal;
  419.                   long var54 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var34, this.getFirstDayOfWeek());
  420.                   var34 += (long)var2;
  421.                   if (var34 < var54) {
  422.                      var34 += 7L;
  423.                   } else if (var34 >= var54 + 7L) {
  424.                      var34 -= 7L;
  425.                   }
  426.  
  427.                   LocalGregorianCalendar.Date var68 = getCalendarDate(var34);
  428.                   this.set(0, getEraIndex(var68));
  429.                   this.set(var68.getYear(), var68.getMonth() - 1, var68.getDayOfMonth());
  430.                   return;
  431.                case 8:
  432.                   var3 = 1;
  433.                   if (this.isTransitionYear(this.jdate.getNormalizedYear())) {
  434.                      long var23 = this.cachedFixedDate;
  435.                      long var44 = this.getFixedDateMonth1(this.jdate, var23);
  436.                      int var63 = this.actualMonthLength();
  437.                      int var67 = var63 % 7;
  438.                      var4 = var63 / 7;
  439.                      int var70 = (int)(var23 - var44) % 7;
  440.                      if (var70 < var67) {
  441.                         ++var4;
  442.                      }
  443.  
  444.                      int var12 = getRolledValue(this.internalGet(var1), var2, var3, var4) - 1;
  445.                      var23 = var44 + (long)(var12 * 7) + (long)var70;
  446.                      LocalGregorianCalendar.Date var13 = getCalendarDate(var23);
  447.                      this.set(5, var13.getDayOfMonth());
  448.                      return;
  449.                   }
  450.  
  451.                   int var22 = this.internalGet(5);
  452.                   int var32 = jcal.getMonthLength(this.jdate);
  453.                   int var43 = var32 % 7;
  454.                   var4 = var32 / 7;
  455.                   int var53 = (var22 - 1) % 7;
  456.                   if (var53 < var43) {
  457.                      ++var4;
  458.                   }
  459.  
  460.                   this.set(7, this.internalGet(7));
  461.                   break;
  462.                case 10:
  463.                case 11:
  464.                   int var5 = var4 + 1;
  465.                   int var6 = this.internalGet(var1);
  466.                   int var7 = (var6 + var2) % var5;
  467.                   if (var7 < 0) {
  468.                      var7 += var5;
  469.                   }
  470.  
  471.                   this.time += (long)(3600000 * (var7 - var6));
  472.                   LocalGregorianCalendar.Date var8 = jcal.getCalendarDate(this.time, this.getZone());
  473.                   if (this.internalGet(5) != ((CalendarDate)var8).getDayOfMonth()) {
  474.                      ((CalendarDate)var8).setEra(this.jdate.getEra());
  475.                      ((CalendarDate)var8).setDate(this.internalGet(1), this.internalGet(2) + 1, this.internalGet(5));
  476.                      if (var1 == 10) {
  477.                         assert this.internalGet(9) == 1;
  478.  
  479.                         ((CalendarDate)var8).addHours(12);
  480.                      }
  481.  
  482.                      this.time = jcal.getTime(var8);
  483.                   }
  484.  
  485.                   int var9 = ((CalendarDate)var8).getHours();
  486.                   this.internalSet(var1, var9 % var5);
  487.                   if (var1 == 10) {
  488.                      this.internalSet(11, var9);
  489.                   } else {
  490.                      this.internalSet(9, var9 / 12);
  491.                      this.internalSet(10, var9 % 12);
  492.                   }
  493.  
  494.                   int var10 = ((CalendarDate)var8).getZoneOffset();
  495.                   int var11 = ((CalendarDate)var8).getDaylightSaving();
  496.                   this.internalSet(15, var10 - var11);
  497.                   this.internalSet(16, var11);
  498.                   return;
  499.             }
  500.  
  501.             this.set(var1, getRolledValue(this.internalGet(var1), var2, var3, var4));
  502.          } else {
  503.             throw new IllegalArgumentException();
  504.          }
  505.       }
  506.    }
  507.  
  508.    public String getDisplayName(int var1, int var2, Locale var3) {
  509.       if (!this.checkDisplayNameParams(var1, var2, 1, 2, var3, 647)) {
  510.          return null;
  511.       } else if (var1 != 1 || var2 != 1 && this.get(1) == 1 && this.get(0) != 0) {
  512.          ResourceBundle var4 = LocaleData.getDateFormatData(var3);
  513.          String var5 = null;
  514.          String var6 = this.getKey(var1, var2);
  515.          if (var6 != null) {
  516.             String[] var7 = var4.getStringArray(var6);
  517.             if (var1 == 1) {
  518.                if (var7.length > 0) {
  519.                   var5 = var7[0];
  520.                }
  521.             } else {
  522.                int var8 = this.get(var1);
  523.                if (var1 == 0 && var8 >= var7.length && var8 < eras.length) {
  524.                   Era var9 = eras[var8];
  525.                   var5 = var2 == 1 ? var9.getAbbreviation() : var9.getName();
  526.                } else {
  527.                   if (var1 == 7) {
  528.                      --var8;
  529.                   }
  530.  
  531.                   var5 = var7[var8];
  532.                }
  533.             }
  534.          }
  535.  
  536.          return var5;
  537.       } else {
  538.          return null;
  539.       }
  540.    }
  541.  
  542.    public Map<String, Integer> getDisplayNames(int var1, int var2, Locale var3) {
  543.       if (!this.checkDisplayNameParams(var1, var2, 0, 2, var3, 647)) {
  544.          return null;
  545.       } else if (var2 == 0) {
  546.          Map var4 = this.getDisplayNamesImpl(var1, 1, var3);
  547.          if (var1 == 9) {
  548.             return var4;
  549.          } else {
  550.             Map var5 = this.getDisplayNamesImpl(var1, 2, var3);
  551.             if (var4 == null) {
  552.                return var5;
  553.             } else {
  554.                if (var5 != null) {
  555.                   var4.putAll(var5);
  556.                }
  557.  
  558.                return var4;
  559.             }
  560.          }
  561.       } else {
  562.          return this.getDisplayNamesImpl(var1, var2, var3);
  563.       }
  564.    }
  565.  
  566.    private Map<String, Integer> getDisplayNamesImpl(int var1, int var2, Locale var3) {
  567.       ResourceBundle var4 = LocaleData.getDateFormatData(var3);
  568.       String var5 = this.getKey(var1, var2);
  569.       HashMap var6 = new HashMap();
  570.       if (var5 != null) {
  571.          String[] var7 = var4.getStringArray(var5);
  572.          if (var1 == 1) {
  573.             if (var7.length > 0) {
  574.                var6.put(var7[0], 1);
  575.             }
  576.          } else {
  577.             int var8 = var1 == 7 ? 1 : 0;
  578.  
  579.             for(int var9 = 0; var9 < var7.length; ++var9) {
  580.                var6.put(var7[var9], var8 + var9);
  581.             }
  582.  
  583.             if (var1 == 0 && var7.length < eras.length) {
  584.                for(int var12 = var7.length; var12 < eras.length; ++var12) {
  585.                   Era var10 = eras[var12];
  586.                   String var11 = var2 == 1 ? var10.getAbbreviation() : var10.getName();
  587.                   var6.put(var11, var12);
  588.                }
  589.             }
  590.          }
  591.       }
  592.  
  593.       return var6.size() > 0 ? var6 : null;
  594.    }
  595.  
  596.    private String getKey(int var1, int var2) {
  597.       String var3 = JapaneseImperialCalendar.class.getName();
  598.       StringBuilder var4 = new StringBuilder();
  599.       switch (var1) {
  600.          case 0:
  601.             var4.append(var3);
  602.             if (var2 == 1) {
  603.                var4.append(".short");
  604.             }
  605.  
  606.             var4.append(".Eras");
  607.             break;
  608.          case 1:
  609.             var4.append(var3).append(".FirstYear");
  610.             break;
  611.          case 2:
  612.             var4.append(var2 == 1 ? "MonthAbbreviations" : "MonthNames");
  613.          case 3:
  614.          case 4:
  615.          case 5:
  616.          case 6:
  617.          case 8:
  618.          default:
  619.             break;
  620.          case 7:
  621.             var4.append(var2 == 1 ? "DayAbbreviations" : "DayNames");
  622.             break;
  623.          case 9:
  624.             var4.append("AmPmMarkers");
  625.       }
  626.  
  627.       return var4.length() > 0 ? var4.toString() : null;
  628.    }
  629.  
  630.    public int getMinimum(int var1) {
  631.       return MIN_VALUES[var1];
  632.    }
  633.  
  634.    public int getMaximum(int var1) {
  635.       switch (var1) {
  636.          case 1:
  637.             LocalGregorianCalendar.Date var2 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  638.             return Math.max(LEAST_MAX_VALUES[1], var2.getYear());
  639.          default:
  640.             return MAX_VALUES[var1];
  641.       }
  642.    }
  643.  
  644.    public int getGreatestMinimum(int var1) {
  645.       return var1 == 1 ? 1 : MIN_VALUES[var1];
  646.    }
  647.  
  648.    public int getLeastMaximum(int var1) {
  649.       switch (var1) {
  650.          case 1:
  651.             return Math.min(LEAST_MAX_VALUES[1], this.getMaximum(1));
  652.          default:
  653.             return LEAST_MAX_VALUES[var1];
  654.       }
  655.    }
  656.  
  657.    public int getActualMinimum(int var1) {
  658.       if (!isFieldSet(14, var1)) {
  659.          return this.getMinimum(var1);
  660.       } else {
  661.          int var2 = 0;
  662.          JapaneseImperialCalendar var3 = this.getNormalizedCalendar();
  663.          LocalGregorianCalendar.Date var4 = jcal.getCalendarDate(var3.getTimeInMillis(), this.getZone());
  664.          int var5 = getEraIndex(var4);
  665.          switch (var1) {
  666.             case 1:
  667.                if (var5 > 0) {
  668.                   var2 = 1;
  669.                   long var15 = eras[var5].getSince(this.getZone());
  670.                   LocalGregorianCalendar.Date var18 = jcal.getCalendarDate(var15, this.getZone());
  671.                   var4.setYear(((CalendarDate)var18).getYear());
  672.                   jcal.normalize(var4);
  673.  
  674.                   assert var4.isLeapYear() == ((CalendarDate)var18).isLeapYear();
  675.  
  676.                   if (this.getYearOffsetInMillis(var4) < this.getYearOffsetInMillis(var18)) {
  677.                      ++var2;
  678.                   }
  679.                } else {
  680.                   var2 = this.getMinimum(var1);
  681.                   LocalGregorianCalendar.Date var16 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  682.                   int var17 = ((CalendarDate)var16).getYear();
  683.                   if (var17 > 400) {
  684.                      var17 -= 400;
  685.                   }
  686.  
  687.                   var4.setYear(var17);
  688.                   jcal.normalize(var4);
  689.                   if (this.getYearOffsetInMillis(var4) < this.getYearOffsetInMillis(var16)) {
  690.                      ++var2;
  691.                   }
  692.                }
  693.                break;
  694.             case 2:
  695.                if (var5 > 1 && var4.getYear() == 1) {
  696.                   long var14 = eras[var5].getSince(this.getZone());
  697.                   LocalGregorianCalendar.Date var8 = jcal.getCalendarDate(var14, this.getZone());
  698.                   var2 = ((CalendarDate)var8).getMonth() - 1;
  699.                   if (var4.getDayOfMonth() < ((CalendarDate)var8).getDayOfMonth()) {
  700.                      ++var2;
  701.                   }
  702.                }
  703.                break;
  704.             case 3:
  705.                var2 = 1;
  706.                LocalGregorianCalendar.Date var6 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  707.                ((CalendarDate)var6).addYear(400);
  708.                jcal.normalize(var6);
  709.                var4.setEra(((CalendarDate)var6).getEra());
  710.                var4.setYear(((CalendarDate)var6).getYear());
  711.                jcal.normalize(var4);
  712.                long var7 = jcal.getFixedDate(var6);
  713.                long var9 = jcal.getFixedDate(var4);
  714.                int var11 = this.getWeekNumber(var7, var9);
  715.                long var12 = var9 - (long)(7 * (var11 - 1));
  716.                if (var12 < var7 || var12 == var7 && var4.getTimeOfDay() < ((CalendarDate)var6).getTimeOfDay()) {
  717.                   ++var2;
  718.                }
  719.          }
  720.  
  721.          return var2;
  722.       }
  723.    }
  724.  
  725.    public int getActualMaximum(int var1) {
  726.       if ((130689 & 1 << var1) != 0) {
  727.          return this.getMaximum(var1);
  728.       } else {
  729.          JapaneseImperialCalendar var3 = this.getNormalizedCalendar();
  730.          LocalGregorianCalendar.Date var4 = var3.jdate;
  731.          int var5 = var4.getNormalizedYear();
  732.          int var6 = -1;
  733.          switch (var1) {
  734.             case 1:
  735.                LocalGregorianCalendar.Date var25 = jcal.getCalendarDate(var3.getTimeInMillis(), this.getZone());
  736.                int var42 = getEraIndex(var4);
  737.                LocalGregorianCalendar.Date var35;
  738.                if (var42 == eras.length - 1) {
  739.                   var35 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  740.                   var6 = ((CalendarDate)var35).getYear();
  741.                   if (var6 > 400) {
  742.                      ((CalendarDate)var25).setYear(var6 - 400);
  743.                   }
  744.                } else {
  745.                   var35 = jcal.getCalendarDate(eras[var42 + 1].getSince(this.getZone()) - 1L, this.getZone());
  746.                   var6 = ((CalendarDate)var35).getYear();
  747.                   ((CalendarDate)var25).setYear(var6);
  748.                }
  749.  
  750.                jcal.normalize(var25);
  751.                if (this.getYearOffsetInMillis(var25) > this.getYearOffsetInMillis(var35)) {
  752.                   --var6;
  753.                }
  754.                break;
  755.             case 2:
  756.                var6 = 11;
  757.                if (this.isTransitionYear(var4.getNormalizedYear())) {
  758.                   int var23 = getEraIndex(var4);
  759.                   if (var4.getYear() != 1) {
  760.                      ++var23;
  761.  
  762.                      assert var23 < eras.length;
  763.                   }
  764.  
  765.                   long var34 = sinceFixedDates[var23];
  766.                   long var50 = var3.cachedFixedDate;
  767.                   if (var50 < var34) {
  768.                      LocalGregorianCalendar.Date var54 = (LocalGregorianCalendar.Date)var4.clone();
  769.                      jcal.getCalendarDateFromFixedDate(var54, var34 - 1L);
  770.                      var6 = var54.getMonth() - 1;
  771.                   }
  772.                } else {
  773.                   LocalGregorianCalendar.Date var24 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  774.                   if (var4.getEra() == var24.getEra() && var4.getYear() == var24.getYear()) {
  775.                      var6 = var24.getMonth() - 1;
  776.                   }
  777.                }
  778.                break;
  779.             case 3:
  780.                if (!this.isTransitionYear(var4.getNormalizedYear())) {
  781.                   LocalGregorianCalendar.Date var21 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  782.                   if (var4.getEra() == var21.getEra() && var4.getYear() == var21.getYear()) {
  783.                      long var33 = jcal.getFixedDate(var21);
  784.                      long var49 = this.getFixedDateJan1(var21, var33);
  785.                      var6 = this.getWeekNumber(var49, var33);
  786.                   } else if (var4.getEra() == null && var4.getYear() == this.getMinimum(1)) {
  787.                      LocalGregorianCalendar.Date var32 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  788.                      ((CalendarDate)var32).addYear(400);
  789.                      jcal.normalize(var32);
  790.                      var21.setEra(((CalendarDate)var32).getEra());
  791.                      var21.setDate(((CalendarDate)var32).getYear() + 1, 1, 1);
  792.                      jcal.normalize(var21);
  793.                      long var41 = jcal.getFixedDate(var32);
  794.                      long var53 = jcal.getFixedDate(var21);
  795.                      LocalGregorianCalendar var10000 = jcal;
  796.                      long var13 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var53 + 6L, this.getFirstDayOfWeek());
  797.                      int var15 = (int)(var13 - var53);
  798.                      if (var15 >= this.getMinimalDaysInFirstWeek()) {
  799.                         var13 -= 7L;
  800.                      }
  801.  
  802.                      var6 = this.getWeekNumber(var41, var13);
  803.                   } else {
  804.                      Gregorian.Date var31 = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  805.                      ((CalendarDate)var31).setDate(var4.getNormalizedYear(), 1, 1);
  806.                      int var39 = gcal.getDayOfWeek(var31);
  807.                      var39 -= this.getFirstDayOfWeek();
  808.                      if (var39 < 0) {
  809.                         var39 += 7;
  810.                      }
  811.  
  812.                      var6 = 52;
  813.                      int var48 = var39 + this.getMinimalDaysInFirstWeek() - 1;
  814.                      if (var48 == 6 || var4.isLeapYear() && (var48 == 5 || var48 == 12)) {
  815.                         ++var6;
  816.                      }
  817.                   }
  818.                } else {
  819.                   if (var3 == this) {
  820.                      var3 = (JapaneseImperialCalendar)var3.clone();
  821.                   }
  822.  
  823.                   int var22 = this.getActualMaximum(6);
  824.                   var3.set(6, var22);
  825.                   var6 = var3.get(3);
  826.                   if (var6 == 1 && var22 > 7) {
  827.                      var3.add(3, -1);
  828.                      var6 = var3.get(3);
  829.                   }
  830.                }
  831.                break;
  832.             case 4:
  833.                LocalGregorianCalendar.Date var20 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  834.                if (var4.getEra() == var20.getEra() && var4.getYear() == var20.getYear()) {
  835.                   long var30 = jcal.getFixedDate(var20);
  836.                   long var47 = var30 - (long)var20.getDayOfMonth() + 1L;
  837.                   var6 = this.getWeekNumber(var47, var30);
  838.                } else {
  839.                   Gregorian.Date var29 = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  840.                   ((CalendarDate)var29).setDate(var4.getNormalizedYear(), var4.getMonth(), 1);
  841.                   int var37 = gcal.getDayOfWeek(var29);
  842.                   int var45 = gcal.getMonthLength(var29);
  843.                   var37 -= this.getFirstDayOfWeek();
  844.                   if (var37 < 0) {
  845.                      var37 += 7;
  846.                   }
  847.  
  848.                   int var52 = 7 - var37;
  849.                   var6 = 3;
  850.                   if (var52 >= this.getMinimalDaysInFirstWeek()) {
  851.                      ++var6;
  852.                   }
  853.  
  854.                   var45 -= var52 + 21;
  855.                   if (var45 > 0) {
  856.                      ++var6;
  857.                      if (var45 > 7) {
  858.                         ++var6;
  859.                      }
  860.                   }
  861.                }
  862.                break;
  863.             case 5:
  864.                var6 = jcal.getMonthLength(var4);
  865.                break;
  866.             case 6:
  867.                if (this.isTransitionYear(var4.getNormalizedYear())) {
  868.                   int var18 = getEraIndex(var4);
  869.                   if (var4.getYear() != 1) {
  870.                      ++var18;
  871.  
  872.                      assert var18 < eras.length;
  873.                   }
  874.  
  875.                   long var26 = sinceFixedDates[var18];
  876.                   long var43 = var3.cachedFixedDate;
  877.                   Gregorian.Date var12 = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  878.                   ((CalendarDate)var12).setDate(var4.getNormalizedYear(), 1, 1);
  879.                   if (var43 < var26) {
  880.                      var6 = (int)(var26 - gcal.getFixedDate(var12));
  881.                   } else {
  882.                      ((CalendarDate)var12).addYear(1);
  883.                      var6 = (int)(gcal.getFixedDate(var12) - var26);
  884.                   }
  885.                } else {
  886.                   LocalGregorianCalendar.Date var19 = jcal.getCalendarDate(Long.MAX_VALUE, this.getZone());
  887.                   if (var4.getEra() == var19.getEra() && var4.getYear() == var19.getYear()) {
  888.                      long var28 = jcal.getFixedDate(var19);
  889.                      long var44 = this.getFixedDateJan1(var19, var28);
  890.                      var6 = (int)(var28 - var44) + 1;
  891.                   } else if (var4.getYear() == this.getMinimum(1)) {
  892.                      LocalGregorianCalendar.Date var27 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  893.                      long var36 = jcal.getFixedDate(var27);
  894.                      ((CalendarDate)var27).addYear(1);
  895.                      ((CalendarDate)var27).setMonth(1).setDayOfMonth(1);
  896.                      jcal.normalize(var27);
  897.                      long var51 = jcal.getFixedDate(var27);
  898.                      var6 = (int)(var51 - var36);
  899.                   } else {
  900.                      var6 = jcal.getYearLength(var4);
  901.                   }
  902.                }
  903.                break;
  904.             case 7:
  905.             default:
  906.                throw new ArrayIndexOutOfBoundsException(var1);
  907.             case 8:
  908.                int var9 = var4.getDayOfWeek();
  909.                BaseCalendar.Date var10 = (BaseCalendar.Date)var4.clone();
  910.                int var7 = jcal.getMonthLength(var10);
  911.                var10.setDayOfMonth(1);
  912.                jcal.normalize(var10);
  913.                int var8 = var10.getDayOfWeek();
  914.                int var11 = var9 - var8;
  915.                if (var11 < 0) {
  916.                   var11 += 7;
  917.                }
  918.  
  919.                var7 -= var11;
  920.                var6 = (var7 + 6) / 7;
  921.          }
  922.  
  923.          return var6;
  924.       }
  925.    }
  926.  
  927.    private final long getYearOffsetInMillis(CalendarDate var1) {
  928.       long var2 = (jcal.getDayOfYear(var1) - 1L) * 86400000L;
  929.       return var2 + var1.getTimeOfDay() - (long)var1.getZoneOffset();
  930.    }
  931.  
  932.    public Object clone() {
  933.       JapaneseImperialCalendar var1 = (JapaneseImperialCalendar)super.clone();
  934.       var1.jdate = (LocalGregorianCalendar.Date)this.jdate.clone();
  935.       var1.originalFields = null;
  936.       var1.zoneOffsets = null;
  937.       return var1;
  938.    }
  939.  
  940.    public TimeZone getTimeZone() {
  941.       TimeZone var1 = super.getTimeZone();
  942.       this.jdate.setZone(var1);
  943.       return var1;
  944.    }
  945.  
  946.    public void setTimeZone(TimeZone var1) {
  947.       super.setTimeZone(var1);
  948.       this.jdate.setZone(var1);
  949.    }
  950.  
  951.    protected void computeFields() {
  952.       int var1 = 0;
  953.       if (this.isPartiallyNormalized()) {
  954.          var1 = this.getSetStateFields();
  955.          int var2 = ~var1 & 131071;
  956.          if (var2 != 0 || this.cachedFixedDate == Long.MIN_VALUE) {
  957.             var1 |= this.computeFields(var2, var1 & 98304);
  958.  
  959.             assert var1 == 131071;
  960.          }
  961.       } else {
  962.          var1 = 131071;
  963.          this.computeFields(var1, 0);
  964.       }
  965.  
  966.       this.setFieldsComputed(var1);
  967.    }
  968.  
  969.    private int computeFields(int var1, int var2) {
  970.       int var3 = 0;
  971.       TimeZone var4 = this.getZone();
  972.       if (this.zoneOffsets == null) {
  973.          this.zoneOffsets = new int[2];
  974.       }
  975.  
  976.       if (var2 != 98304) {
  977.          if (var4 instanceof ZoneInfo) {
  978.             var3 = ((ZoneInfo)var4).getOffsets(this.time, this.zoneOffsets);
  979.          } else {
  980.             var3 = var4.getOffset(this.time);
  981.             this.zoneOffsets[0] = var4.getRawOffset();
  982.             this.zoneOffsets[1] = var3 - this.zoneOffsets[0];
  983.          }
  984.       }
  985.  
  986.       if (var2 != 0) {
  987.          if (isFieldSet(var2, 15)) {
  988.             this.zoneOffsets[0] = this.internalGet(15);
  989.          }
  990.  
  991.          if (isFieldSet(var2, 16)) {
  992.             this.zoneOffsets[1] = this.internalGet(16);
  993.          }
  994.  
  995.          var3 = this.zoneOffsets[0] + this.zoneOffsets[1];
  996.       }
  997.  
  998.       long var5 = (long)var3 / 86400000L;
  999.       int var7 = var3 % 86400000;
  1000.       var5 += this.time / 86400000L;
  1001.       var7 += (int)(this.time % 86400000L);
  1002.       if ((long)var7 >= 86400000L) {
  1003.          var7 = (int)((long)var7 - 86400000L);
  1004.          ++var5;
  1005.       } else {
  1006.          while(var7 < 0) {
  1007.             var7 = (int)((long)var7 + 86400000L);
  1008.             --var5;
  1009.          }
  1010.       }
  1011.  
  1012.       var5 += 719163L;
  1013.       if (var5 != this.cachedFixedDate || var5 < 0L) {
  1014.          jcal.getCalendarDateFromFixedDate(this.jdate, var5);
  1015.          this.cachedFixedDate = var5;
  1016.       }
  1017.  
  1018.       int var8 = getEraIndex(this.jdate);
  1019.       int var9 = this.jdate.getYear();
  1020.       this.internalSet(0, var8);
  1021.       this.internalSet(1, var9);
  1022.       int var10 = var1 | 3;
  1023.       int var11 = this.jdate.getMonth() - 1;
  1024.       int var12 = this.jdate.getDayOfMonth();
  1025.       if ((var1 & 164) != 0) {
  1026.          this.internalSet(2, var11);
  1027.          this.internalSet(5, var12);
  1028.          this.internalSet(7, this.jdate.getDayOfWeek());
  1029.          var10 |= 164;
  1030.       }
  1031.  
  1032.       if ((var1 & 32256) != 0) {
  1033.          if (var7 != 0) {
  1034.             int var13 = var7 / 3600000;
  1035.             this.internalSet(11, var13);
  1036.             this.internalSet(9, var13 / 12);
  1037.             this.internalSet(10, var13 % 12);
  1038.             int var14 = var7 % 3600000;
  1039.             this.internalSet(12, var14 / '\uea60');
  1040.             var14 %= 60000;
  1041.             this.internalSet(13, var14 / 1000);
  1042.             this.internalSet(14, var14 % 1000);
  1043.          } else {
  1044.             this.internalSet(11, 0);
  1045.             this.internalSet(9, 0);
  1046.             this.internalSet(10, 0);
  1047.             this.internalSet(12, 0);
  1048.             this.internalSet(13, 0);
  1049.             this.internalSet(14, 0);
  1050.          }
  1051.  
  1052.          var10 |= 32256;
  1053.       }
  1054.  
  1055.       if ((var1 & 98304) != 0) {
  1056.          this.internalSet(15, this.zoneOffsets[0]);
  1057.          this.internalSet(16, this.zoneOffsets[1]);
  1058.          var10 |= 98304;
  1059.       }
  1060.  
  1061.       if ((var1 & 344) != 0) {
  1062.          int var30 = this.jdate.getNormalizedYear();
  1063.          boolean var32 = this.isTransitionYear(this.jdate.getNormalizedYear());
  1064.          int var15;
  1065.          long var16;
  1066.          if (var32) {
  1067.             var16 = this.getFixedDateJan1(this.jdate, var5);
  1068.             var15 = (int)(var5 - var16) + 1;
  1069.          } else if (var30 == MIN_VALUES[1]) {
  1070.             LocalGregorianCalendar.Date var18 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  1071.             var16 = jcal.getFixedDate(var18);
  1072.             var15 = (int)(var5 - var16) + 1;
  1073.          } else {
  1074.             var15 = (int)jcal.getDayOfYear(this.jdate);
  1075.             var16 = var5 - (long)var15 + 1L;
  1076.          }
  1077.  
  1078.          long var33 = var32 ? this.getFixedDateMonth1(this.jdate, var5) : var5 - (long)var12 + 1L;
  1079.          this.internalSet(6, var15);
  1080.          this.internalSet(8, (var12 - 1) / 7 + 1);
  1081.          int var20 = this.getWeekNumber(var16, var5);
  1082.          if (var20 != 0) {
  1083.             if (!var32) {
  1084.                if (var20 >= 52) {
  1085.                   long var34 = var16 + 365L;
  1086.                   if (this.jdate.isLeapYear()) {
  1087.                      ++var34;
  1088.                   }
  1089.  
  1090.                   LocalGregorianCalendar var10000 = jcal;
  1091.                   long var36 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var34 + 6L, this.getFirstDayOfWeek());
  1092.                   int var38 = (int)(var36 - var34);
  1093.                   if (var38 >= this.getMinimalDaysInFirstWeek() && var5 >= var36 - 7L) {
  1094.                      var20 = 1;
  1095.                   }
  1096.                }
  1097.             } else {
  1098.                LocalGregorianCalendar.Date var35 = (LocalGregorianCalendar.Date)this.jdate.clone();
  1099.                long var22;
  1100.                if (this.jdate.getYear() == 1) {
  1101.                   var35.addYear(1);
  1102.                   LocalGregorianCalendar var43 = jcal;
  1103.                   var35.setMonth(1).setDayOfMonth(1);
  1104.                   var22 = jcal.getFixedDate(var35);
  1105.                } else {
  1106.                   int var24 = getEraIndex(var35) + 1;
  1107.                   CalendarDate var39 = eras[var24].getSinceDate();
  1108.                   var35.setEra(eras[var24]);
  1109.                   var35.setDate(1, var39.getMonth(), var39.getDayOfMonth());
  1110.                   jcal.normalize(var35);
  1111.                   var22 = jcal.getFixedDate(var35);
  1112.                }
  1113.  
  1114.                LocalGregorianCalendar var42 = jcal;
  1115.                long var37 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var22 + 6L, this.getFirstDayOfWeek());
  1116.                int var41 = (int)(var37 - var22);
  1117.                if (var41 >= this.getMinimalDaysInFirstWeek() && var5 >= var37 - 7L) {
  1118.                   var20 = 1;
  1119.                }
  1120.             }
  1121.          } else {
  1122.             long var21 = var16 - 1L;
  1123.             LocalGregorianCalendar.Date var25 = getCalendarDate(var21);
  1124.             long var23;
  1125.             if (!var32 && !this.isTransitionYear(var25.getNormalizedYear())) {
  1126.                var23 = var16 - 365L;
  1127.                if (var25.isLeapYear()) {
  1128.                   --var23;
  1129.                }
  1130.             } else if (var32) {
  1131.                if (this.jdate.getYear() == 1) {
  1132.                   if (var8 > 4) {
  1133.                      CalendarDate var26 = eras[var8 - 1].getSinceDate();
  1134.                      if (var30 == var26.getYear()) {
  1135.                         var25.setMonth(var26.getMonth()).setDayOfMonth(var26.getDayOfMonth());
  1136.                      }
  1137.                   } else {
  1138.                      LocalGregorianCalendar var10001 = jcal;
  1139.                      var25.setMonth(1).setDayOfMonth(1);
  1140.                   }
  1141.  
  1142.                   jcal.normalize(var25);
  1143.                   var23 = jcal.getFixedDate(var25);
  1144.                } else {
  1145.                   var23 = var16 - 365L;
  1146.                   if (var25.isLeapYear()) {
  1147.                      --var23;
  1148.                   }
  1149.                }
  1150.             } else {
  1151.                CalendarDate var40 = eras[getEraIndex(this.jdate)].getSinceDate();
  1152.                var25.setMonth(var40.getMonth()).setDayOfMonth(var40.getDayOfMonth());
  1153.                jcal.normalize(var25);
  1154.                var23 = jcal.getFixedDate(var25);
  1155.             }
  1156.  
  1157.             var20 = this.getWeekNumber(var23, var21);
  1158.          }
  1159.  
  1160.          this.internalSet(3, var20);
  1161.          this.internalSet(4, this.getWeekNumber(var33, var5));
  1162.          var10 |= 344;
  1163.       }
  1164.  
  1165.       return var10;
  1166.    }
  1167.  
  1168.    private final int getWeekNumber(long var1, long var3) {
  1169.       LocalGregorianCalendar var10000 = jcal;
  1170.       long var5 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var1 + 6L, this.getFirstDayOfWeek());
  1171.       int var7 = (int)(var5 - var1);
  1172.  
  1173.       assert var7 <= 7;
  1174.  
  1175.       if (var7 >= this.getMinimalDaysInFirstWeek()) {
  1176.          var5 -= 7L;
  1177.       }
  1178.  
  1179.       int var8 = (int)(var3 - var5);
  1180.       return var8 >= 0 ? var8 / 7 + 1 : CalendarUtils.floorDivide(var8, 7) + 1;
  1181.    }
  1182.  
  1183.    protected void computeTime() {
  1184.       if (!this.isLenient()) {
  1185.          if (this.originalFields == null) {
  1186.             this.originalFields = new int[17];
  1187.          }
  1188.  
  1189.          for(int var1 = 0; var1 < 17; ++var1) {
  1190.             int var2 = this.internalGet(var1);
  1191.             if (this.isExternallySet(var1) && (var2 < this.getMinimum(var1) || var2 > this.getMaximum(var1))) {
  1192.                throw new IllegalArgumentException(getFieldName(var1));
  1193.             }
  1194.  
  1195.             this.originalFields[var1] = var2;
  1196.          }
  1197.       }
  1198.  
  1199.       int var15 = this.selectFields();
  1200.       int var3;
  1201.       int var16;
  1202.       if (this.isSet(0)) {
  1203.          var3 = this.internalGet(0);
  1204.          var16 = this.isSet(1) ? this.internalGet(1) : 1;
  1205.       } else if (this.isSet(1)) {
  1206.          var3 = eras.length - 1;
  1207.          var16 = this.internalGet(1);
  1208.       } else {
  1209.          var3 = 3;
  1210.          var16 = 45;
  1211.       }
  1212.  
  1213.       long var4 = 0L;
  1214.       if (isFieldSet(var15, 11)) {
  1215.          var4 += (long)this.internalGet(11);
  1216.       } else {
  1217.          var4 += (long)this.internalGet(10);
  1218.          if (isFieldSet(var15, 9)) {
  1219.             var4 += (long)(12 * this.internalGet(9));
  1220.          }
  1221.       }
  1222.  
  1223.       var4 *= 60L;
  1224.       var4 += (long)this.internalGet(12);
  1225.       var4 *= 60L;
  1226.       var4 += (long)this.internalGet(13);
  1227.       var4 *= 1000L;
  1228.       var4 += (long)this.internalGet(14);
  1229.       long var6 = var4 / 86400000L;
  1230.  
  1231.       for(var4 %= 86400000L; var4 < 0L; --var6) {
  1232.          var4 += 86400000L;
  1233.       }
  1234.  
  1235.       var6 += this.getFixedDate(var3, var16, var15);
  1236.       long var8 = (var6 - 719163L) * 86400000L + var4;
  1237.       TimeZone var10 = this.getZone();
  1238.       if (this.zoneOffsets == null) {
  1239.          this.zoneOffsets = new int[2];
  1240.       }
  1241.  
  1242.       int var11 = var15 & 98304;
  1243.       if (var11 != 98304) {
  1244.          if (var10 instanceof ZoneInfo) {
  1245.             ((ZoneInfo)var10).getOffsetsByWall(var8, this.zoneOffsets);
  1246.          } else {
  1247.             var10.getOffsets(var8 - (long)var10.getRawOffset(), this.zoneOffsets);
  1248.          }
  1249.       }
  1250.  
  1251.       if (var11 != 0) {
  1252.          if (isFieldSet(var11, 15)) {
  1253.             this.zoneOffsets[0] = this.internalGet(15);
  1254.          }
  1255.  
  1256.          if (isFieldSet(var11, 16)) {
  1257.             this.zoneOffsets[1] = this.internalGet(16);
  1258.          }
  1259.       }
  1260.  
  1261.       var8 -= (long)(this.zoneOffsets[0] + this.zoneOffsets[1]);
  1262.       this.time = var8;
  1263.       int var12 = this.computeFields(var15 | this.getSetStateFields(), var11);
  1264.       if (!this.isLenient()) {
  1265.          for(int var13 = 0; var13 < 17; ++var13) {
  1266.             if (this.isExternallySet(var13) && this.originalFields[var13] != this.internalGet(var13)) {
  1267.                int var14 = this.internalGet(var13);
  1268.                System.arraycopy(this.originalFields, 0, this.fields, 0, this.fields.length);
  1269.                throw new IllegalArgumentException(getFieldName(var13) + "=" + var14 + ", expected " + this.originalFields[var13]);
  1270.             }
  1271.          }
  1272.       }
  1273.  
  1274.       this.setFieldsNormalized(var12);
  1275.    }
  1276.  
  1277.    private long getFixedDate(int var1, int var2, int var3) {
  1278.       int var4 = 0;
  1279.       int var5 = 1;
  1280.       if (isFieldSet(var3, 2)) {
  1281.          var4 = this.internalGet(2);
  1282.          if (var4 > 11) {
  1283.             var2 += var4 / 12;
  1284.             var4 %= 12;
  1285.          } else if (var4 < 0) {
  1286.             int[] var6 = new int[1];
  1287.             var2 += CalendarUtils.floorDivide(var4, 12, var6);
  1288.             var4 = var6[0];
  1289.          }
  1290.       } else if (var2 == 1 && var1 != 0) {
  1291.          CalendarDate var12 = eras[var1].getSinceDate();
  1292.          var4 = var12.getMonth() - 1;
  1293.          var5 = var12.getDayOfMonth();
  1294.       }
  1295.  
  1296.       if (var2 == MIN_VALUES[1]) {
  1297.          LocalGregorianCalendar.Date var13 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  1298.          int var7 = ((CalendarDate)var13).getMonth() - 1;
  1299.          if (var4 < var7) {
  1300.             var4 = var7;
  1301.          }
  1302.  
  1303.          if (var4 == var7) {
  1304.             var5 = ((CalendarDate)var13).getDayOfMonth();
  1305.          }
  1306.       }
  1307.  
  1308.       LocalGregorianCalendar.Date var14 = jcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  1309.       var14.setEra(var1 > 0 ? eras[var1] : null);
  1310.       var14.setDate(var2, var4 + 1, var5);
  1311.       jcal.normalize(var14);
  1312.       long var17 = jcal.getFixedDate(var14);
  1313.       if (isFieldSet(var3, 2)) {
  1314.          if (isFieldSet(var3, 5)) {
  1315.             if (this.isSet(5)) {
  1316.                var17 += (long)this.internalGet(5);
  1317.                var17 -= (long)var5;
  1318.             }
  1319.          } else if (isFieldSet(var3, 4)) {
  1320.             LocalGregorianCalendar var10000 = jcal;
  1321.             long var9 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var17 + 6L, this.getFirstDayOfWeek());
  1322.             if (var9 - var17 >= (long)this.getMinimalDaysInFirstWeek()) {
  1323.                var9 -= 7L;
  1324.             }
  1325.  
  1326.             if (isFieldSet(var3, 7)) {
  1327.                var10000 = jcal;
  1328.                var9 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var9 + 6L, this.internalGet(7));
  1329.             }
  1330.  
  1331.             var17 = var9 + (long)(7 * (this.internalGet(4) - 1));
  1332.          } else {
  1333.             int var18;
  1334.             if (isFieldSet(var3, 7)) {
  1335.                var18 = this.internalGet(7);
  1336.             } else {
  1337.                var18 = this.getFirstDayOfWeek();
  1338.             }
  1339.  
  1340.             int var10;
  1341.             if (isFieldSet(var3, 8)) {
  1342.                var10 = this.internalGet(8);
  1343.             } else {
  1344.                var10 = 1;
  1345.             }
  1346.  
  1347.             if (var10 >= 0) {
  1348.                LocalGregorianCalendar var22 = jcal;
  1349.                var17 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var17 + (long)(7 * var10) - 1L, var18);
  1350.             } else {
  1351.                int var11 = this.monthLength(var4, var2) + 7 * (var10 + 1);
  1352.                LocalGregorianCalendar var23 = jcal;
  1353.                var17 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var17 + (long)var11 - 1L, var18);
  1354.             }
  1355.          }
  1356.       } else if (isFieldSet(var3, 6)) {
  1357.          if (this.isTransitionYear(var14.getNormalizedYear())) {
  1358.             var17 = this.getFixedDateJan1(var14, var17);
  1359.          }
  1360.  
  1361.          var17 += (long)this.internalGet(6);
  1362.          --var17;
  1363.       } else {
  1364.          LocalGregorianCalendar var24 = jcal;
  1365.          long var19 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var17 + 6L, this.getFirstDayOfWeek());
  1366.          if (var19 - var17 >= (long)this.getMinimalDaysInFirstWeek()) {
  1367.             var19 -= 7L;
  1368.          }
  1369.  
  1370.          if (isFieldSet(var3, 7)) {
  1371.             int var20 = this.internalGet(7);
  1372.             if (var20 != this.getFirstDayOfWeek()) {
  1373.                var24 = jcal;
  1374.                var19 = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(var19 + 6L, var20);
  1375.             }
  1376.          }
  1377.  
  1378.          var17 = var19 + 7L * ((long)this.internalGet(3) - 1L);
  1379.       }
  1380.  
  1381.       return var17;
  1382.    }
  1383.  
  1384.    private final long getFixedDateJan1(LocalGregorianCalendar.Date var1, long var2) {
  1385.       Era var4 = var1.getEra();
  1386.       if (var1.getEra() != null && var1.getYear() == 1) {
  1387.          for(int var5 = getEraIndex(var1); var5 > 0; --var5) {
  1388.             CalendarDate var6 = eras[var5].getSinceDate();
  1389.             long var7 = gcal.getFixedDate(var6);
  1390.             if (var7 <= var2) {
  1391.                return var7;
  1392.             }
  1393.          }
  1394.       }
  1395.  
  1396.       Gregorian.Date var9 = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  1397.       int var10001 = var1.getNormalizedYear();
  1398.       Gregorian var10002 = gcal;
  1399.       ((CalendarDate)var9).setDate(var10001, 1, 1);
  1400.       return gcal.getFixedDate(var9);
  1401.    }
  1402.  
  1403.    private final long getFixedDateMonth1(LocalGregorianCalendar.Date var1, long var2) {
  1404.       int var4 = getTransitionEraIndex(var1);
  1405.       if (var4 != -1) {
  1406.          long var5 = sinceFixedDates[var4];
  1407.          if (var5 <= var2) {
  1408.             return var5;
  1409.          }
  1410.       }
  1411.  
  1412.       return var2 - (long)var1.getDayOfMonth() + 1L;
  1413.    }
  1414.  
  1415.    private static final LocalGregorianCalendar.Date getCalendarDate(long var0) {
  1416.       LocalGregorianCalendar.Date var2 = jcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  1417.       jcal.getCalendarDateFromFixedDate(var2, var0);
  1418.       return var2;
  1419.    }
  1420.  
  1421.    private final int monthLength(int var1, int var2) {
  1422.       return CalendarUtils.isGregorianLeapYear(var2) ? GregorianCalendar.LEAP_MONTH_LENGTH[var1] : GregorianCalendar.MONTH_LENGTH[var1];
  1423.    }
  1424.  
  1425.    private final int monthLength(int var1) {
  1426.       assert this.jdate.isNormalized();
  1427.  
  1428.       return this.jdate.isLeapYear() ? GregorianCalendar.LEAP_MONTH_LENGTH[var1] : GregorianCalendar.MONTH_LENGTH[var1];
  1429.    }
  1430.  
  1431.    private final int actualMonthLength() {
  1432.       int var1 = jcal.getMonthLength(this.jdate);
  1433.       int var2 = getTransitionEraIndex(this.jdate);
  1434.       if (var2 == -1) {
  1435.          long var3 = sinceFixedDates[var2];
  1436.          CalendarDate var5 = eras[var2].getSinceDate();
  1437.          if (var3 <= this.cachedFixedDate) {
  1438.             var1 -= var5.getDayOfMonth() - 1;
  1439.          } else {
  1440.             var1 = var5.getDayOfMonth() - 1;
  1441.          }
  1442.       }
  1443.  
  1444.       return var1;
  1445.    }
  1446.  
  1447.    private static final int getTransitionEraIndex(LocalGregorianCalendar.Date var0) {
  1448.       int var1 = getEraIndex(var0);
  1449.       CalendarDate var2 = eras[var1].getSinceDate();
  1450.       if (var2.getYear() == var0.getNormalizedYear() && var2.getMonth() == var0.getMonth()) {
  1451.          return var1;
  1452.       } else {
  1453.          if (var1 < eras.length - 1) {
  1454.             ++var1;
  1455.             var2 = eras[var1].getSinceDate();
  1456.             if (var2.getYear() == var0.getNormalizedYear() && var2.getMonth() == var0.getMonth()) {
  1457.                return var1;
  1458.             }
  1459.          }
  1460.  
  1461.          return -1;
  1462.       }
  1463.    }
  1464.  
  1465.    private final boolean isTransitionYear(int var1) {
  1466.       for(int var2 = eras.length - 1; var2 > 0; --var2) {
  1467.          int var3 = eras[var2].getSinceDate().getYear();
  1468.          if (var1 == var3) {
  1469.             return true;
  1470.          }
  1471.  
  1472.          if (var1 > var3) {
  1473.             break;
  1474.          }
  1475.       }
  1476.  
  1477.       return false;
  1478.    }
  1479.  
  1480.    private static final int getEraIndex(LocalGregorianCalendar.Date var0) {
  1481.       Era var1 = var0.getEra();
  1482.  
  1483.       for(int var2 = eras.length - 1; var2 > 0; --var2) {
  1484.          if (eras[var2] == var1) {
  1485.             return var2;
  1486.          }
  1487.       }
  1488.  
  1489.       return 0;
  1490.    }
  1491.  
  1492.    private final JapaneseImperialCalendar getNormalizedCalendar() {
  1493.       JapaneseImperialCalendar var1;
  1494.       if (this.isFullyNormalized()) {
  1495.          var1 = this;
  1496.       } else {
  1497.          var1 = (JapaneseImperialCalendar)this.clone();
  1498.          var1.setLenient(true);
  1499.          var1.complete();
  1500.       }
  1501.  
  1502.       return var1;
  1503.    }
  1504.  
  1505.    private final void pinDayOfMonth(LocalGregorianCalendar.Date var1) {
  1506.       int var2 = var1.getYear();
  1507.       int var3 = var1.getDayOfMonth();
  1508.       if (var2 != this.getMinimum(1)) {
  1509.          var1.setDayOfMonth(1);
  1510.          jcal.normalize(var1);
  1511.          int var4 = jcal.getMonthLength(var1);
  1512.          if (var3 > var4) {
  1513.             var1.setDayOfMonth(var4);
  1514.          } else {
  1515.             var1.setDayOfMonth(var3);
  1516.          }
  1517.  
  1518.          jcal.normalize(var1);
  1519.       } else {
  1520.          LocalGregorianCalendar.Date var9 = jcal.getCalendarDate(Long.MIN_VALUE, this.getZone());
  1521.          LocalGregorianCalendar.Date var5 = jcal.getCalendarDate(this.time, this.getZone());
  1522.          long var6 = var5.getTimeOfDay();
  1523.          var5.addYear(400);
  1524.          var5.setMonth(var1.getMonth());
  1525.          var5.setDayOfMonth(1);
  1526.          jcal.normalize(var5);
  1527.          int var8 = jcal.getMonthLength(var5);
  1528.          if (var3 > var8) {
  1529.             var5.setDayOfMonth(var8);
  1530.          } else if (var3 < var9.getDayOfMonth()) {
  1531.             var5.setDayOfMonth(var9.getDayOfMonth());
  1532.          } else {
  1533.             var5.setDayOfMonth(var3);
  1534.          }
  1535.  
  1536.          if (var5.getDayOfMonth() == var9.getDayOfMonth() && var6 < var9.getTimeOfDay()) {
  1537.             var5.setDayOfMonth(Math.min(var3 + 1, var8));
  1538.          }
  1539.  
  1540.          var1.setDate(var2, var5.getMonth(), var5.getDayOfMonth());
  1541.       }
  1542.  
  1543.    }
  1544.  
  1545.    private static final int getRolledValue(int var0, int var1, int var2, int var3) {
  1546.       assert var0 >= var2 && var0 <= var3;
  1547.  
  1548.       int var4 = var3 - var2 + 1;
  1549.       var1 %= var4;
  1550.       int var5 = var0 + var1;
  1551.       if (var5 > var3) {
  1552.          var5 -= var4;
  1553.       } else if (var5 < var2) {
  1554.          var5 += var4;
  1555.       }
  1556.  
  1557.       assert var5 >= var2 && var5 <= var3;
  1558.  
  1559.       return var5;
  1560.    }
  1561.  
  1562.    private final int internalGetEra() {
  1563.       return this.isSet(0) ? this.internalGet(0) : eras.length - 1;
  1564.    }
  1565.  
  1566.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  1567.       var1.defaultReadObject();
  1568.       if (this.jdate == null) {
  1569.          this.jdate = jcal.newCalendarDate(this.getZone());
  1570.          this.cachedFixedDate = Long.MIN_VALUE;
  1571.       }
  1572.  
  1573.    }
  1574.  
  1575.    static {
  1576.       Era[] var0 = jcal.getEras();
  1577.       int var1 = var0.length + 1;
  1578.       eras = new Era[var1];
  1579.       sinceFixedDates = new long[var1];
  1580.       int var2 = 0;
  1581.       sinceFixedDates[var2] = gcal.getFixedDate(BEFORE_MEIJI_ERA.getSinceDate());
  1582.       eras[var2++] = BEFORE_MEIJI_ERA;
  1583.  
  1584.       for(Era var6 : var0) {
  1585.          CalendarDate var7 = var6.getSinceDate();
  1586.          sinceFixedDates[var2] = gcal.getFixedDate(var7);
  1587.          eras[var2++] = var6;
  1588.       }
  1589.  
  1590.       LEAST_MAX_VALUES[0] = MAX_VALUES[0] = eras.length - 1;
  1591.       int var15 = Integer.MAX_VALUE;
  1592.       int var16 = Integer.MAX_VALUE;
  1593.       Gregorian.Date var18 = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
  1594.  
  1595.       for(int var19 = 1; var19 < eras.length; ++var19) {
  1596.          long var20 = sinceFixedDates[var19];
  1597.          CalendarDate var9 = eras[var19].getSinceDate();
  1598.          ((CalendarDate)var18).setDate(var9.getYear(), 1, 1);
  1599.          long var10 = gcal.getFixedDate(var18);
  1600.          var16 = Math.min((int)(var10 - var20), var16);
  1601.          ((CalendarDate)var18).setDate(var9.getYear(), 12, 31);
  1602.          var10 = gcal.getFixedDate(var18) + 1L;
  1603.          var16 = Math.min((int)(var20 - var10), var16);
  1604.          LocalGregorianCalendar.Date var12 = getCalendarDate(var20 - 1L);
  1605.          int var13 = var12.getYear();
  1606.          if (var12.getMonth() != 1 || var12.getDayOfMonth() != 1) {
  1607.             --var13;
  1608.          }
  1609.  
  1610.          var15 = Math.min(var13, var15);
  1611.       }
  1612.  
  1613.       LEAST_MAX_VALUES[1] = var15;
  1614.       LEAST_MAX_VALUES[6] = var16;
  1615.    }
  1616. }
  1617.